Understanding the Use of Inheritance with Visual Patterns

International audienceThe goal of this work is to visualize inheritance in object-oriented programs to help its comprehension. We propose a single, compact view of all class hierarchies at once using a custom Sunburst layout. It enables to quickly discover interesting facts across classes while preserving the essential relationship between parent and children classes. We explain how standard inheritance metrics are mapped into our visualization. Additionally, we define a new metric characterizing similar children classes. Using these metrics and the proposed layout, a set of common visual patterns is derived. These patterns allow the programmer to quickly understand how inheritance is used and provide answers to some essential questions when performing program comprehension tasks. Our approach is evaluated through a case study that involves examples from large programs, demonstrating its scalability

Expression and Composition of Design Patterns with AspectJ

National audienceDesign patterns are well-known couples of problems-solutions for software engineer- ing. By nature, they often lack support from languages and this further complicates the study of their composition in the code. Aspect-oriented languages provide new mechanisms for modula- rization, which can help to improve design patterns implementation. (Hannemann et al., 2002) is the first extensive study of patterns aspectization with AspectJ. We notice some AspectJ idioms are needed in order to implement object relationships. We give a more reusable VISITOR pat- tern. We highlight a reusable composition of COMPOSITE and VISITOR patterns and expressive interactions of the OBSERVER pattern with a tree structure. We thus show that modularization by aspects helps composition of design patterns

Proceedings of the 3rd Workshop on FAMIX and MOOSE in Software Reengineering (FAMOOSr'09)

International audienceThe goal of the FAMOOSr workshop is to strengthen the community of researchers and practitioners who are working in re- and reverse engineering, by providing a forum for building future research using Moose and FAMIX as shared infrastructure. Research should be collaborative and supported by tools. The increasing amount of data available about software systems poses new challenges for reengineering research, as the proposed approaches need to scale. In this context, concerns about meta-modeling and analysis techniques need to be augmented by technical concerns about how to reuse and how to build upon the efforts of previous research. That is why Moose is an open-source software for researchers to build and share their analysis, meta-models, and data. Both FAMIX and Moose started in the context of FAMOOS, a European research project on object-oriented frameworks. Back in 1997 Moose was as a simple implementation of the FAMIX meta-model, which was a language independent meta-model for object-oriented systems. However over the past decade, Moose has been used in a growing number of research projects and has evolved to be a generic environment for various reverse and reengineering activities. In the same time, FAMIX was extended to support emerging research interest such as dynamic analysis, evolution analysis, identifier analysis, bug tracking analysis, or visualization. Recent work includes analysis of software architecture and semantic annotations. Currently, several research groups are using Moose as a platform, or FAMIX as a meta-model, and other groups announced interest in using them in the future

Proposals for the Reborn Pharo Developer

International audienceSmalltalk was at the birth of current IDEs. Current Smalltalk IDEs, however, lost their abilities to adapt to developer needs (edit and jump, back button, auto-completion,...). Therefore while offering a powerful sets of tools current Smalltalk IDEs looks clunky and often lacks the application of a consistent set of guidelines. In this paper we sketch some possible IDEs future features or reorganization

Cycles Assessment with CycleTable

Understanding the package organization of a large application is a challenging and critical task since it allows developers to better maintain the application. Several ap- proaches show in different ways software structure. Fewer show modularity issues at the package level. We focus on modularity issues due to cyclic dependencies between packages. Most approaches detect Strongly Connected Components (SCC) in a graph of dependencies. However, SCC detection does not allow one to easily understand and remove cyclic dependencies in legacy software displaying dozens of packages all dependent on each other. This paper presents i) a heuristic to focus on shared dependencies between cycles in SCC and ii) CycleTable, a visualization showing interesting dependencies to efficiently remove cycles in the system. This visualization is completed with enriched cells, small views displaying the internals of a dependency [LDDB09]. We performed i) a case study which shows that the shared dependency heuristic highlights dependencies to be removed, and ii) a comparative study which shows that CycleTable is useful for the task of breaking cycles in a SCC compared to a normal node-link representation

Visualisations pour la remodularisation à large échelle des systèmes à objets

National audienceDans ce chapitre, nous abordons deux points critiques de la remodularisa- tion : comment visualiser la structure d'un logiciel pour aider à la rendre mod- ulaire et comment aider le développeur à prendre les bonnes décisions. D'abord nous décrivons certains outils pour visualiser la structure des logiciels et comment nous les adaptons à la remodularisation. Ensuite nous présentons des visualisations adaptées à l'identification des problèmes de modularité. Enfin, nous proposons un outil, nommé Orion, permettant de simuler les changements de structure d'un logi- ciel. Il permet d'analyser l'impact des changements dans la structure et d'évaluer les coûts associés

Identifying cycle causes with Enriched Dependency Structural Matrix

International audienceDependency Structure Matrix (DSM) has been successfully applied to identify software dependencies among packages and subsystems. A number of algorithms were proposed to compute the matrix so that it highlights patterns and problematic dependencies between subsystems. However, existing DSM implementations often miss important informa- tion to fully support reengineering effort. For example, they do not clearly qualify and quantify problematic relationships, information which is crucial to support remediation tasks. In this paper we present enriched DSM (eDSM) where cells are enriched with contextual information about (i) the type of dependencies (inheritance, class reference . . . ), (ii) the proportion of referencing entities, (iii) the proportion of ref- erenced entities. We distinguish independent cycles and stress potentially simple fixes for cycles using coloring information. This work is language independent and has been implemented on top of the Moose reengineering environment. It has been applied to non-trivial case studies among which ArgoUML, and Morphic the UI framework available in two open-source Smalltalks, Squeak and Pharo. Solution to problems identified by eDSM have been performed and retrofitted in Pharo main distribution

Technical and Economical Model (Workpackage 2.1)

The objective of this workpackage is to define a model for (i) assessing the effort of software modification, (ii) identifying healing actions following practices from the Squale quality model defined in the previous workpackage (WP1.3). It defines the input for the next workpackage which is about planning actions once their effort is characterized. The key constraints of this work are: • The remediation effort should be expressed in the context of a quality model. It should act as a quantification of the work to obtain a better (or good) quality of the entity under analysis. • The remediation should be based on practices as described in the workpackage 1.3

AspectMaps: A Scalable Visualization of Join Point Shadows

International audienceWhen using Aspect-Oriented Programming, it is sometimes difficult to determine at which join point an aspect executes. Similarly, when considering one join point, knowing which aspects will execute there and in what order is non- trivial. This makes it difficult to understand how the application will behave. A number of visualizations have been proposed that attempt to provide support for such program understanding. However, they neither scale up to large code bases nor scale down to understanding what happens at a single join point. In this paper, we present AspectMaps - a visualization that scales in both directions, thanks to a multi-level selective structural zoom. We show how the use of AspectMaps allows for program understanding of code with aspects, revealing both a wealth of information of what can happen at one particular join point as well as allowing to see the "big picture" on a larger code base. We demonstrate the usefulness of AspectMaps on an example and present the results of a small user study that shows that AspectMaps outperforms other aspect visualization tools